home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / a_utils / flex / amiga / flex.lha / Flex.src.lha / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-13  |  20.0 KB  |  792 lines
  1. /* flex - tool to generate fast lexical analyzers */
  2.  
  3. /*-
  4.  * Copyright (c) 1990 The Regents of the University of California.
  5.  * All rights reserved.
  6.  *
  7.  * This code is derived from software contributed to Berkeley by
  8.  * Vern Paxson.
  9.  * 
  10.  * The United States Government has rights in this work pursuant
  11.  * to contract no. DE-AC03-76SF00098 between the United States
  12.  * Department of Energy and the University of California.
  13.  *
  14.  * Redistribution and use in source and binary forms are permitted provided
  15.  * that: (1) source distributions retain this entire copyright notice and
  16.  * comment, and (2) distributions including binaries display the following
  17.  * acknowledgement:  ``This product includes software developed by the
  18.  * University of California, Berkeley and its contributors'' in the
  19.  * documentation or other materials provided with the distribution and in
  20.  * all advertising materials mentioning features or use of this software.
  21.  * Neither the name of the University nor the names of its contributors may
  22.  * be used to endorse or promote products derived from this software without
  23.  * specific prior written permission.
  24.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  25.  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  26.  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  27.  */
  28.  
  29. #ifndef lint
  30. char copyright[] =
  31. "@(#) Copyright (c) 1990 The Regents of the University of California.\n\
  32.  All rights reserved.\n";
  33. #endif /* not lint */
  34.  
  35. #ifndef lint
  36. static char rcsid[] =
  37.     "@(#) $Header: /usr/fsys/odin/a/vern/flex/RCS/main.c,v 2.9 90/06/27 23:48:24 vern Exp $ (LBL)";
  38. #endif
  39.  
  40.  
  41. #include "flexdef.h"
  42.  
  43. #ifdef AMIGA
  44. #include "dfa.i" /* Include the prototypes */
  45. #include "main.i"
  46. #include "misc.i"
  47. #include "ecs.i"
  48. #include "gen.i"
  49. #include <clib/exec_protos.h>
  50. #endif
  51.  
  52. static char flex_version[] = "2.3";
  53.  
  54.  
  55. /* declare functions that have forward references */
  56.  
  57. void flexinit PROTO((int, char**));
  58. void readin PROTO(());
  59. void set_up_initial_allocations PROTO(());
  60.  
  61.  
  62. /* these globals are all defined and commented in flexdef.h */
  63. int printstats, syntaxerror, eofseen, ddebug, trace, spprdflt;
  64. int interactive, caseins, useecs, fulltbl, usemecs;
  65. int fullspd, gen_line_dirs, performance_report, backtrack_report, csize;
  66. int yymore_used, reject, real_reject, continued_action;
  67. int yymore_really_used, reject_really_used;
  68. int datapos, dataline, linenum;
  69. FILE *skelfile = NULL;
  70. char *infilename = NULL;
  71. int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE];
  72. int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp;
  73. int current_mns, num_rules, current_max_rules, lastnfa;
  74. int *firstst, *lastst, *finalst, *transchar, *trans1, *trans2;
  75. int *accptnum, *assoc_rule, *state_type, *rule_type, *rule_linenum;
  76. int current_state_type;
  77. int variable_trailing_context_rules;
  78. int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP];
  79. int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE];
  80. int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs, tecfwd[CSIZE + 1];
  81. int tecbck[CSIZE + 1];
  82. int *xlation = (int *) 0;
  83. int num_xlations;
  84. int lastsc, current_max_scs, *scset, *scbol, *scxclu, *sceof, *actvsc;
  85. char **scname;
  86. int current_max_dfa_size, current_max_xpairs;
  87. int current_max_template_xpairs, current_max_dfas;
  88. int lastdfa, *nxt, *chk, *tnxt;
  89. int *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, *dfasiz;
  90. union dfaacc_union *dfaacc;
  91. int *accsiz, *dhash, numas;
  92. int numsnpairs, jambase, jamstate;
  93. int lastccl, current_maxccls, *cclmap, *ccllen, *cclng, cclreuse;
  94. int current_max_ccl_tbl_size;
  95. Char *ccltbl;
  96. char *starttime, *endtime, nmstr[MAXLINE];
  97. int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs;
  98. int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave;
  99. int num_backtracking, bol_needed;
  100. FILE *temp_action_file;
  101. FILE *backtrack_file;
  102. int end_of_buffer_state;
  103. char *action_file_name = NULL;
  104. char **input_files;
  105. int num_input_files;
  106. char *program_name;
  107.  
  108. #ifndef SHORT_FILE_NAMES
  109. static char *outfile = "lex.yy.c";
  110. #else
  111. static char *outfile = "lexyy.c";
  112. #endif
  113. static int outfile_created = 0;
  114. static int use_stdout;
  115. static char *skelname = NULL;
  116.  
  117. #ifdef AMIGA
  118. char *                                                                         
  119. TmpFileName(template)                                                          
  120. char *template;                                                                
  121. {                                                                              
  122.     static char Template[256];                                                 
  123.     static unsigned short Idx;                                                 
  124.                                                                                
  125.     sprintf(Template, "%s-%08lx.TMP", template, (long)FindTask(NULL) + Idx++); 
  126.     return(Template);                                                          
  127. }
  128. #endif
  129.  
  130. int main( argc, argv )
  131. int argc;
  132. char **argv;
  133.  
  134.     {
  135.     flexinit( argc, argv );
  136.  
  137.     readin();
  138.  
  139.     if ( syntaxerror )
  140.     flexend( 1 );
  141.  
  142.     if ( yymore_really_used == REALLY_USED )
  143.     yymore_used = true;
  144.     else if ( yymore_really_used == REALLY_NOT_USED )
  145.     yymore_used = false;
  146.  
  147.     if ( reject_really_used == REALLY_USED )
  148.     reject = true;
  149.     else if ( reject_really_used == REALLY_NOT_USED )
  150.     reject = false;
  151.  
  152.     if ( performance_report )
  153.     {
  154.     if ( interactive )
  155.         fprintf( stderr,
  156.              "-I (interactive) entails a minor performance penalty\n" );
  157.  
  158.     if ( yymore_used )
  159.         fprintf( stderr, "yymore() entails a minor performance penalty\n" );
  160.  
  161.     if ( reject )
  162.         fprintf( stderr, "REJECT entails a large performance penalty\n" );
  163.  
  164.     if ( variable_trailing_context_rules )
  165.         fprintf( stderr,
  166. "Variable trailing context rules entail a large performance penalty\n" );
  167.     }
  168.  
  169.     if ( reject )
  170.     real_reject = true;
  171.  
  172.     if ( variable_trailing_context_rules )
  173.     reject = true;
  174.  
  175.     if ( (fulltbl || fullspd) && reject )
  176.     {
  177.     if ( real_reject )
  178.         flexerror( "REJECT cannot be used with -f or -F" );
  179.     else
  180.         flexerror(
  181.     "variable trailing context rules cannot be used with -f or -F" );
  182.     }
  183.  
  184.     ntod();
  185.  
  186.     /* generate the C state transition tables from the DFA */
  187.     make_tables();
  188.  
  189.     /* note, flexend does not return.  It exits with its argument as status. */
  190.  
  191.     flexend( 0 );
  192.  
  193.     /*NOTREACHED*/
  194.     }
  195.  
  196.  
  197. /* flexend - terminate flex
  198.  *
  199.  * synopsis
  200.  *    int status;
  201.  *    flexend( status );
  202.  *
  203.  *    status is exit status.
  204.  *
  205.  * note
  206.  *    This routine does not return.
  207.  */
  208.  
  209. void flexend( status )
  210. int status;
  211.  
  212.     {
  213.     int tblsiz;
  214.     char *flex_gettime();
  215.  
  216.     if ( skelfile != NULL )
  217.     {
  218.     if ( ferror( skelfile ) )
  219.         flexfatal( "error occurred when writing skeleton file" );
  220.  
  221.     else if ( fclose( skelfile ) )
  222.         flexfatal( "error occurred when closing skeleton file" );
  223.     }
  224.  
  225.     if ( temp_action_file )
  226.     {
  227.     if ( ferror( temp_action_file ) )
  228.         flexfatal( "error occurred when writing temporary action file" );
  229.  
  230.     else if ( fclose( temp_action_file ) )
  231.         flexfatal( "error occurred when closing temporary action file" );
  232.  
  233.     else if ( unlink( action_file_name ) )
  234.         flexfatal( "error occurred when deleting temporary action file" );
  235.     }
  236.  
  237.     if ( status != 0 && outfile_created )
  238.     {
  239.     if ( ferror( stdout ) )
  240.         flexfatal( "error occurred when writing output file" );
  241.  
  242.     else if ( fclose( stdout ) )
  243.         flexfatal( "error occurred when closing output file" );
  244.  
  245.     else if ( unlink( outfile ) )
  246.         flexfatal( "error occurred when deleting output file" );
  247.     }
  248.  
  249.     if ( backtrack_report && backtrack_file )
  250.     {
  251.     if ( num_backtracking == 0 )
  252.         fprintf( backtrack_file, "No backtracking.\n" );
  253.     else if ( fullspd || fulltbl )
  254.         fprintf( backtrack_file,
  255.              "%d backtracking (non-accepting) states.\n",
  256.              num_backtracking );
  257.     else
  258.         fprintf( backtrack_file, "Compressed tables always backtrack.\n" );
  259.  
  260.     if ( ferror( backtrack_file ) )
  261.         flexfatal( "error occurred when writing backtracking file" );
  262.  
  263.     else if ( fclose( backtrack_file ) )
  264.         flexfatal( "error occurred when closing backtracking file" );
  265.     }
  266.  
  267.     if ( printstats )
  268.     {
  269.     endtime = flex_gettime();
  270.  
  271.     fprintf( stderr, "%s version %s usage statistics:\n", program_name,
  272.          flex_version );
  273.     fprintf( stderr, "  started at %s, finished at %s\n",
  274.          starttime, endtime );
  275.  
  276.     fprintf( stderr, "  scanner options: -" );
  277.  
  278.     if ( backtrack_report )
  279.         putc( 'b', stderr );
  280.     if ( ddebug )
  281.         putc( 'd', stderr );
  282.     if ( interactive )
  283.         putc( 'I', stderr );
  284.     if ( caseins )
  285.         putc( 'i', stderr );
  286.     if ( ! gen_line_dirs )
  287.         putc( 'L', stderr );
  288.     if ( performance_report )
  289.         putc( 'p', stderr );
  290.     if ( spprdflt )
  291.         putc( 's', stderr );
  292.     if ( use_stdout )
  293.         putc( 't', stderr );
  294.     if ( trace )
  295.         putc( 'T', stderr );
  296.     if ( printstats )
  297.         putc( 'v', stderr );    /* always true! */
  298.     if ( csize == 256 )
  299.         putc( '8', stderr );
  300.  
  301.     fprintf( stderr, " -C" );
  302.  
  303.     if ( fulltbl )
  304.         putc( 'f', stderr );
  305.     if ( fullspd )
  306.         putc( 'F', stderr );
  307.     if ( useecs )
  308.         putc( 'e', stderr );
  309.     if ( usemecs )
  310.         putc( 'm', stderr );
  311.  
  312.     if ( strcmp( skelname, DEFAULT_SKELETON_FILE ) )
  313.         fprintf( stderr, " -S%s", skelname );
  314.  
  315.     putc( '\n', stderr );
  316.  
  317.     fprintf( stderr, "  %d/%d NFA states\n", lastnfa, current_mns );
  318.     fprintf( stderr, "  %d/%d DFA states (%d words)\n", lastdfa,
  319.          current_max_dfas, totnst );
  320.     fprintf( stderr,
  321.          "  %d rules\n", num_rules - 1 /* - 1 for def. rule */ );
  322.  
  323.     if ( num_backtracking == 0 )
  324.         fprintf( stderr, "  No backtracking\n" );
  325.     else if ( fullspd || fulltbl )
  326.         fprintf( stderr, "  %d backtracking (non-accepting) states\n",
  327.              num_backtracking );
  328.     else
  329.         fprintf( stderr, "  compressed tables always backtrack\n" );
  330.  
  331.     if ( bol_needed )
  332.         fprintf( stderr, "  Beginning-of-line patterns used\n" );
  333.  
  334.     fprintf( stderr, "  %d/%d start conditions\n", lastsc,
  335.          current_max_scs );
  336.     fprintf( stderr, "  %d epsilon states, %d double epsilon states\n",
  337.          numeps, eps2 );
  338.  
  339.     if ( lastccl == 0 )
  340.         fprintf( stderr, "  no character classes\n" );
  341.     else
  342.         fprintf( stderr,
  343.     "  %d/%d character classes needed %d/%d words of storage, %d reused\n",
  344.              lastccl, current_maxccls,
  345.              cclmap[lastccl] + ccllen[lastccl],
  346.              current_max_ccl_tbl_size, cclreuse );
  347.  
  348.     fprintf( stderr, "  %d state/nextstate pairs created\n", numsnpairs );
  349.     fprintf( stderr, "  %d/%d unique/duplicate transitions\n",
  350.          numuniq, numdup );
  351.  
  352.     if ( fulltbl )
  353.         {
  354.         tblsiz = lastdfa * numecs;
  355.         fprintf( stderr, "  %d table entries\n", tblsiz );
  356.         }
  357.  
  358.     else
  359.         {
  360.         tblsiz = 2 * (lastdfa + numtemps) + 2 * tblend;
  361.  
  362.         fprintf( stderr, "  %d/%d base-def entries created\n",
  363.              lastdfa + numtemps, current_max_dfas );
  364.         fprintf( stderr, "  %d/%d (peak %d) nxt-chk entries created\n",
  365.              tblend, current_max_xpairs, peakpairs );
  366.         fprintf( stderr,
  367.              "  %d/%d (peak %d) template nxt-chk entries created\n",
  368.              numtemps * nummecs, current_max_template_xpairs,
  369.              numtemps * numecs );
  370.         fprintf( stderr, "  %d empty table entries\n", nummt );
  371.         fprintf( stderr, "  %d protos created\n", numprots );
  372.         fprintf( stderr, "  %d templates created, %d uses\n",
  373.              numtemps, tmpuses );
  374.         }
  375.  
  376.     if ( useecs )
  377.         {
  378.         tblsiz = tblsiz + csize;
  379.         fprintf( stderr, "  %d/%d equivalence classes created\n",
  380.              numecs, csize );
  381.         }
  382.  
  383.     if ( usemecs )
  384.         {
  385.         tblsiz = tblsiz + numecs;
  386.         fprintf( stderr, "  %d/%d meta-equivalence classes created\n",
  387.              nummecs, csize );
  388.         }
  389.  
  390.     fprintf( stderr, "  %d (%d saved) hash collisions, %d DFAs equal\n",
  391.          hshcol, hshsave, dfaeql );
  392.     fprintf( stderr, "  %d sets of reallocations needed\n", num_reallocs );
  393.     fprintf( stderr, "  %d total table entries needed\n", tblsiz );
  394.     }
  395.  
  396. #ifndef VMS
  397.     exit( status );
  398. #else
  399.     exit( status + 1 );
  400. #endif
  401.     }
  402.  
  403.  
  404. /* flexinit - initialize flex
  405.  *
  406.  * synopsis
  407.  *    int argc;
  408.  *    char **argv;
  409.  *    flexinit( argc, argv );
  410.  */
  411.  
  412. void flexinit( argc, argv )
  413. int argc;
  414. char **argv;
  415.  
  416.     {
  417.     int i, sawcmpflag;
  418.     char *arg, *flex_gettime(), *mktemp();
  419.  
  420.     printstats = syntaxerror = trace = spprdflt = interactive = caseins = false;
  421.     backtrack_report = performance_report = ddebug = fulltbl = fullspd = false;
  422.     yymore_used = continued_action = reject = false;
  423.     yymore_really_used = reject_really_used = false;
  424.     gen_line_dirs = usemecs = useecs = true;
  425.  
  426.     sawcmpflag = false;
  427.     use_stdout = false;
  428.  
  429.     csize = DEFAULT_CSIZE;
  430.  
  431.     program_name = argv[0];
  432.  
  433.     /* read flags */
  434.     for ( --argc, ++argv; argc ; --argc, ++argv )
  435.     {
  436.     if ( argv[0][0] != '-' || argv[0][1] == '\0' )
  437.         break;
  438.  
  439.     arg = argv[0];
  440.  
  441.     for ( i = 1; arg[i] != '\0'; ++i )
  442.         switch ( arg[i] )
  443.         {
  444.         case 'b':
  445.             backtrack_report = true;
  446.             break;
  447.  
  448.         case 'c':
  449.             fprintf( stderr,
  450.     "%s: Assuming use of deprecated -c flag is really intended to be -C\n",
  451.                  program_name );
  452.  
  453.             /* fall through */
  454.  
  455.         case 'C':
  456.             if ( i != 1 )
  457.             flexerror( "-C flag must be given separately" );
  458.  
  459.             if ( ! sawcmpflag )
  460.             {
  461.             useecs = false;
  462.             usemecs = false;
  463.             fulltbl = false;
  464.             sawcmpflag = true;
  465.             }
  466.  
  467.             for ( ++i; arg[i] != '\0'; ++i )
  468.             switch ( arg[i] )
  469.                 {
  470.                 case 'e':
  471.                 useecs = true;
  472.                 break;
  473.  
  474.                 case 'F':
  475.                 fullspd = true;
  476.                 break;
  477.  
  478.                 case 'f':
  479.                 fulltbl = true;
  480.                 break;
  481.  
  482.                 case 'm':
  483.                 usemecs = true;
  484.                 break;
  485.  
  486.                 default:
  487.                 lerrif( "unknown -C option '%c'",
  488.                     (int) arg[i] );
  489.                 break;
  490.                 }
  491.  
  492.             goto get_next_arg;
  493.  
  494.         case 'd':
  495.             ddebug = true;
  496.             break;
  497.  
  498.         case 'f':
  499.             useecs = usemecs = false;
  500.             fulltbl = true;
  501.             break;
  502.  
  503.         case 'F':
  504.             useecs = usemecs = false;
  505.             fullspd = true;
  506.             break;
  507.  
  508.         case 'I':
  509.             interactive = true;
  510.             break;
  511.  
  512.         case 'i':
  513.             caseins = true;
  514.             break;
  515.  
  516.         case 'L':
  517.             gen_line_dirs = false;
  518.             break;
  519.  
  520.         case 'n':
  521.             /* stupid do-nothing deprecated option */
  522.             break;
  523.  
  524.         case 'p':
  525.             performance_report = true;
  526.             break;
  527.  
  528.         case 'S':
  529.             if ( i != 1 )
  530.             flexerror( "-S flag must be given separately" );
  531.  
  532.             skelname = arg + i + 1;
  533.             goto get_next_arg;
  534.  
  535.         case 's':
  536.             spprdflt = true;
  537.             break;
  538.  
  539.         case 't':
  540.             use_stdout = true;
  541.             break;
  542.  
  543.         case 'T':
  544.             trace = true;
  545.             break;
  546.  
  547.         case 'v':
  548.             printstats = true;
  549.             break;
  550.  
  551.         case '8':
  552.             csize = CSIZE;
  553.             break;
  554.  
  555.         default:
  556.             lerrif( "unknown flag '%c'", (int) arg[i] );
  557.             break;
  558.         }
  559.  
  560. get_next_arg: /* used by -C and -S flags in lieu of a "continue 2" control */
  561.     ;
  562.     }
  563.  
  564.     if ( (fulltbl || fullspd) && usemecs )
  565.     flexerror( "full table and -Cm don't make sense together" );
  566.  
  567.     if ( (fulltbl || fullspd) && interactive )
  568.     flexerror( "full table and -I are (currently) incompatible" );
  569.  
  570.     if ( fulltbl && fullspd )
  571.     flexerror( "full table and -F are mutually exclusive" );
  572.  
  573.     if ( ! skelname )
  574.     {
  575.     static char skeleton_name_storage[400];
  576.  
  577.     skelname = skeleton_name_storage;
  578.     (void) strcpy( skelname, DEFAULT_SKELETON_FILE );
  579.     }
  580.  
  581.     if ( ! use_stdout )
  582.     {
  583.     FILE *prev_stdout = freopen( outfile, "w", stdout );
  584.  
  585.     if ( prev_stdout == NULL )
  586.         lerrsf( "could not create %s", outfile );
  587.  
  588.     outfile_created = 1;
  589.     }
  590.  
  591.     num_input_files = argc;
  592.     input_files = argv;
  593.     set_input_file( num_input_files > 0 ? input_files[0] : NULL );
  594.  
  595.     if ( backtrack_report )
  596.     {
  597. #ifndef SHORT_FILE_NAMES
  598.     backtrack_file = fopen( "lex.backtrack", "w" );
  599. #else
  600.     backtrack_file = fopen( "lex.bck", "w" );
  601. #endif
  602.  
  603.     if ( backtrack_file == NULL )
  604.         flexerror( "could not create lex.backtrack" );
  605.     }
  606.  
  607.     else
  608.     backtrack_file = NULL;
  609.  
  610.  
  611.     lastccl = 0;
  612.     lastsc = 0;
  613.  
  614.     /* initialize the statistics */
  615.     starttime = flex_gettime();
  616.  
  617.     if ( (skelfile = fopen( skelname, "r" )) == NULL )
  618.     lerrsf( "can't open skeleton file %s", skelname );
  619.  
  620. #ifdef SYS_V
  621.     action_file_name = tmpnam( NULL );
  622. #endif
  623.  
  624.     if ( action_file_name == NULL )
  625.     {
  626.     static char temp_action_file_name[32];
  627.  
  628. #ifdef AMIGA
  629.     (void) strcpy( temp_action_file_name, TmpFileName("t:flex") );
  630. #else
  631. #ifndef SHORT_FILE_NAMES
  632.     (void) strcpy( temp_action_file_name, "/tmp/flexXXXXXX" );
  633. #else
  634.     (void) strcpy( temp_action_file_name, "flexXXXXXX.tmp" );
  635. #endif
  636.     (void) mktemp( temp_action_file_name );
  637. #endif
  638.     action_file_name = temp_action_file_name;
  639.     }
  640.  
  641.     if ( (temp_action_file = fopen( action_file_name, "w" )) == NULL )
  642.     lerrsf( "can't open temporary action file %s", action_file_name );
  643.  
  644.     lastdfa = lastnfa = num_rules = numas = numsnpairs = tmpuses = 0;
  645.     numecs = numeps = eps2 = num_reallocs = hshcol = dfaeql = totnst = 0;
  646.     numuniq = numdup = hshsave = eofseen = datapos = dataline = 0;
  647.     num_backtracking = onesp = numprots = 0;
  648.     variable_trailing_context_rules = bol_needed = false;
  649.  
  650.     linenum = sectnum = 1;
  651.     firstprot = NIL;
  652.  
  653.     /* used in mkprot() so that the first proto goes in slot 1
  654.      * of the proto queue
  655.      */
  656.     lastprot = 1;
  657.  
  658.     if ( useecs )
  659.     { /* set up doubly-linked equivalence classes */
  660.     /* We loop all the way up to csize, since ecgroup[csize] is the
  661.      * position used for NUL characters
  662.      */
  663.     ecgroup[1] = NIL;
  664.  
  665.     for ( i = 2; i <= csize; ++i )
  666.         {
  667.         ecgroup[i] = i - 1;
  668.         nextecm[i - 1] = i;
  669.         }
  670.  
  671.     nextecm[csize] = NIL;
  672.     }
  673.  
  674.     else
  675.     { /* put everything in its own equivalence class */
  676.     for ( i = 1; i <= csize; ++i )
  677.         {
  678.         ecgroup[i] = i;
  679.         nextecm[i] = BAD_SUBSCRIPT;    /* to catch errors */
  680.         }
  681.     }
  682.  
  683.     set_up_initial_allocations();
  684.     }
  685.  
  686.  
  687. /* readin - read in the rules section of the input file(s)
  688.  *
  689.  * synopsis
  690.  *    readin();
  691.  */
  692.  
  693. void readin()
  694.  
  695.     {
  696.     skelout();
  697.  
  698.     if ( ddebug )
  699.     puts( "#define FLEX_DEBUG" );
  700.  
  701.     if ( csize == 256 )
  702.     puts( "#define YY_CHAR unsigned char" );
  703.     else
  704.     puts( "#define YY_CHAR char" );
  705.  
  706.     line_directive_out( stdout );
  707.  
  708.     if ( yyparse() )
  709.     {
  710.     pinpoint_message( "fatal parse error" );
  711.     flexend( 1 );
  712.     }
  713.  
  714.     if ( xlation )
  715.     {
  716.     numecs = ecs_from_xlation( ecgroup );
  717.     useecs = true;
  718.     }
  719.  
  720.     else if ( useecs )
  721.     numecs = cre8ecs( nextecm, ecgroup, csize );
  722.  
  723.     else
  724.     numecs = csize;
  725.  
  726.     /* now map the equivalence class for NUL to its expected place */
  727.     ecgroup[0] = ecgroup[csize];
  728.     NUL_ec = abs( ecgroup[0] );
  729.  
  730.     if ( useecs )
  731.     ccl2ecl();
  732.     }
  733.  
  734.  
  735.  
  736. /* set_up_initial_allocations - allocate memory for internal tables */
  737.  
  738. void set_up_initial_allocations()
  739.  
  740.     {
  741.     current_mns = INITIAL_MNS;
  742.     firstst = allocate_integer_array( current_mns );
  743.     lastst = allocate_integer_array( current_mns );
  744.     finalst = allocate_integer_array( current_mns );
  745.     transchar = allocate_integer_array( current_mns );
  746.     trans1 = allocate_integer_array( current_mns );
  747.     trans2 = allocate_integer_array( current_mns );
  748.     accptnum = allocate_integer_array( current_mns );
  749.     assoc_rule = allocate_integer_array( current_mns );
  750.     state_type = allocate_integer_array( current_mns );
  751.  
  752.     current_max_rules = INITIAL_MAX_RULES;
  753.     rule_type = allocate_integer_array( current_max_rules );
  754.     rule_linenum = allocate_integer_array( current_max_rules );
  755.  
  756.     current_max_scs = INITIAL_MAX_SCS;
  757.     scset = allocate_integer_array( current_max_scs );
  758.     scbol = allocate_integer_array( current_max_scs );
  759.     scxclu = allocate_integer_array( current_max_scs );
  760.     sceof = allocate_integer_array( current_max_scs );
  761.     scname = allocate_char_ptr_array( current_max_scs );
  762.     actvsc = allocate_integer_array( current_max_scs );
  763.  
  764.     current_maxccls = INITIAL_MAX_CCLS;
  765.     cclmap = allocate_integer_array( current_maxccls );
  766.     ccllen = allocate_integer_array( current_maxccls );
  767.     cclng = allocate_integer_array( current_maxccls );
  768.  
  769.     current_max_ccl_tbl_size = INITIAL_MAX_CCL_TBL_SIZE;
  770.     ccltbl = allocate_character_array( current_max_ccl_tbl_size );
  771.  
  772.     current_max_dfa_size = INITIAL_MAX_DFA_SIZE;
  773.  
  774.     current_max_xpairs = INITIAL_MAX_XPAIRS;
  775.     nxt = allocate_integer_array( current_max_xpairs );
  776.     chk = allocate_integer_array( current_max_xpairs );
  777.  
  778.     current_max_template_xpairs = INITIAL_MAX_TEMPLATE_XPAIRS;
  779.     tnxt = allocate_integer_array( current_max_template_xpairs );
  780.  
  781.     current_max_dfas = INITIAL_MAX_DFAS;
  782.     base = allocate_integer_array( current_max_dfas );
  783.     def = allocate_integer_array( current_max_dfas );
  784.     dfasiz = allocate_integer_array( current_max_dfas );
  785.     accsiz = allocate_integer_array( current_max_dfas );
  786.     dhash = allocate_integer_array( current_max_dfas );
  787.     dss = allocate_int_ptr_array( current_max_dfas );
  788.     dfaacc = allocate_dfaacc_union( current_max_dfas );
  789.  
  790.     nultrans = (int *) 0;
  791.     }
  792.